const fs = require('fs');
const path = require('path');
const xlsx = require('xlsx');
const readline = require('readline');

// 创建命令行交互接口
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 彩种规则配置（前区数量、后区数量）
const lotteryRules = {
    ssq: { frontCount: 6, backCount: 1, name: '双色球' },    // 双色球：6前1后
    dlt: { frontCount: 5, backCount: 2, name: '大乐透' },    // 大乐透：5前2后
    fc3d: { frontCount: 3, backCount: 0, name: '福彩3D' },   // 福彩3D：3前0后
    plc: { frontCount: 3, backCount: 0, name: '排列三' },    // 排列三：3前0后
    // 可根据需要添加其他彩种规则
};

/**
 * 获取当前目录下的所有Excel文件
 * @returns {Array} Excel文件列表
 */
function getExcelFiles() {
    const files = fs.readdirSync('.');
    const excelFiles = files.filter(file => {
        const ext = path.extname(file).toLowerCase();
        return ext === '.xls' || ext === '.xlsx';
    });
    return excelFiles;
}

/**
 * 处理XLS文件并转换为指定格式
 * @param {string} filePath - XLS文件路径
 * @param {string} type - 彩种类型（ssq/dlt/fc3d等）
 * @param {Object} columnMap - 列映射关系
 * @returns {Array} 转换后的结果数组
 */
function processLotteryXls(filePath, type, columnMap) {
    try {
        // 验证彩种规则
        if (!lotteryRules[type]) {
            throw new Error(`不支持的彩种类型：${type}`);
        }
        const rule = lotteryRules[type];

        // 读取并解析XLS文件
        const workbook = xlsx.readFile(filePath);
        const firstSheetName = workbook.SheetNames[0];
        const worksheet = workbook.Sheets[firstSheetName];
        const jsonData = xlsx.utils.sheet_to_json(worksheet, { header: 1 }); // 以数组形式读取（首行为索引0）

        // 从第三行开始处理数据（前两行是表头）
        if (jsonData.length <= 2) {
            console.log('文件中没有有效数据（至少需要3行，前两行为表头）');
            return [];
        }

        const result = [];
        // 从第三行开始处理数据（索引为2）
        for (let i = 2; i < jsonData.length; i++) {
            const row = jsonData[i];
            if (!row.length) continue; // 跳过空行

            // 提取基础数据（根据列映射获取对应位置的数据）
            const drawNumber = row[columnMap.drawNumber]?.toString().trim();
            const date = row[columnMap.date]?.toString().trim();
            const firstPrizeCount = Number(row[columnMap.firstPrizeCount] || 0);
            const secondPrizeCount = Number(row[columnMap.secondPrizeCount] || 0);

            // 验证必要数据
            if (!drawNumber || !date) {
                console.warn(`第${i+1}行数据不完整，跳过处理`);
                continue;
            }

            // 提取号码（根据彩种规则处理前区和后区）
            const numbers = [];
            // 收集号码列数据（假设号码从指定列开始连续排列）
            for (let j = columnMap.numbersStart; j < columnMap.numbersStart + (rule.frontCount + rule.backCount); j++) {
                const num = row[j]?.toString().trim();
                if (num) numbers.push(num);
            }

            // 验证号码数量
            if (numbers.length !== rule.frontCount + rule.backCount) {
                console.warn(`第${i+1}期号码数量不符，跳过处理`);
                continue;
            }

            // 分割前区和后区号码
            const front = numbers.slice(0, rule.frontCount);
            const item = {
                type,
                typeName: rule.name,
                front,
                drawNumber: Number(drawNumber),
                date,
                firstPrizeCount,
                secondPrizeCount
            };

            // 存在后区时添加后区数据
            if (rule.backCount > 0) {
                item.back = numbers.slice(rule.frontCount);
            }

            result.push(item);
        }

        return result;
    } catch (error) {
        console.error('处理文件出错：', error.message);
        return [];
    }
}

/**
 * 收集用户输入的函数
 */
async function collectUserInput() {
    try {
        // 1. 选择Excel文件
        const excelFiles = getExcelFiles();
        if (excelFiles.length === 0) {
            throw new Error('当前目录下未找到任何.xls或.xlsx文件');
        }
        
        console.log('\n请选择要处理的Excel文件：');
        excelFiles.forEach((file, index) => {
            console.log(`${index + 1}. ${file}`);
        });
        
        const filePath = await new Promise(resolve => {
            rl.question(`请输入文件编号(1-${excelFiles.length})：`, (answer) => {
                const index = parseInt(answer) - 1;
                if (index >= 0 && index < excelFiles.length) {
                    resolve(excelFiles[index]);
                } else {
                    console.log('输入的编号无效，请重新输入');
                    resolve(getFileSelection());
                }
            });
            
            function getFileSelection() {
                return new Promise(resolve => {
                    rl.question(`请输入有效的文件编号(1-${excelFiles.length})：`, (answer) => {
                        const index = parseInt(answer) - 1;
                        if (index >= 0 && index < excelFiles.length) {
                            resolve(excelFiles[index]);
                        } else {
                            console.log('输入的编号仍然无效，请重新输入');
                            resolve(getFileSelection());
                        }
                    });
                });
            }
        });
        
        // 2. 选择彩种类型
        console.log('\n请选择彩种类型：');
        const lotteryTypes = Object.entries(lotteryRules);
        lotteryTypes.forEach(([key, value], index) => {
            console.log(`${index + 1}. ${value.name} (${key})`);
        });
        
        const type = await new Promise(resolve => {
            rl.question(`请输入彩种编号(1-${lotteryTypes.length})：`, (answer) => {
                const index = parseInt(answer) - 1;
                if (index >= 0 && index < lotteryTypes.length) {
                    resolve(lotteryTypes[index][0]);
                } else {
                    console.log('输入的编号无效，请重新输入');
                    resolve(getLotteryTypeSelection());
                }
            });
            
            function getLotteryTypeSelection() {
                return new Promise(resolve => {
                    rl.question(`请输入有效的彩种编号(1-${lotteryTypes.length})：`, (answer) => {
                        const index = parseInt(answer) - 1;
                        if (index >= 0 && index < lotteryTypes.length) {
                            resolve(lotteryTypes[index][0]);
                        } else {
                            console.log('输入的编号仍然无效，请重新输入');
                            resolve(getLotteryTypeSelection());
                        }
                    });
                });
            }
        });
        
        // 3. 输入列映射信息
        console.log('\n请输入以下列的索引（从0开始）：');
        
        const drawNumber = await askNumberInput('期号所在列索引: ');
        const date = await askNumberInput('开奖日期所在列索引: ');
        const numbersStart = await askNumberInput('号码开始的列索引: ');
        const firstPrizeCount = await askNumberInput('一等奖数量所在列索引: ');
        const secondPrizeCount = await askNumberInput('二等奖数量所在列索引: ');
        
        return {
            filePath,
            type,
            columnMap: {
                drawNumber,
                date,
                numbersStart,
                firstPrizeCount,
                secondPrizeCount
            }
        };
    } catch (error) {
        console.error('获取用户输入出错：', error.message);
        rl.close();
        process.exit(1);
    }
}

/**
 * 询问数字输入并验证
 */
function askNumberInput(question) {
    return new Promise(resolve => {
        rl.question(question, (answer) => {
            const num = parseInt(answer);
            if (!isNaN(num) && num >= 0) {
                resolve(num);
            } else {
                console.log('请输入有效的非负整数');
                resolve(askNumberInput(question));
            }
        });
    });
}

// 主函数
async function main() {
    try {
        console.log('欢迎使用彩票Excel数据处理工具');
        console.log('本工具将从第三行开始处理数据（前两行为表头）\n');
        
        // 获取用户输入
        const userInput = await collectUserInput();
        rl.close();
        
        // 处理Excel文件
        console.log('\n开始处理文件...');
        const result = processLotteryXls(
            userInput.filePath, 
            userInput.type, 
            userInput.columnMap
        );
        
        if (result.length > 0) {
            // 生成输出文件名
            const baseName = path.basename(userInput.filePath, path.extname(userInput.filePath));
            const outputFileName = `${baseName}_${userInput.type}_result_${new Date().getTime()}.json`;
            
            // 保存结果到JSON文件
            fs.writeFileSync(outputFileName, JSON.stringify(result, null, 2), 'utf8');
            console.log(`处理完成，共处理${result.length}条数据`);
            console.log(`结果已保存至: ${outputFileName}`);
        } else {
            console.log('未处理到有效数据');
        }
    } catch (error) {
        console.error('程序出错:', error.message);
    }
}

// 启动程序
main();
